Подаци о врсти транспорта

Студент: Стефан Ковач 4003/2020

Професор: Ненад Митић

Асистент: Мирјана Маљковић

Индустрија 4.0, Математички факултет и Машински факултет, Универзитет у Београду

У овом скупу података налазе се подаци о мерењима сензора у различитим врстама транспорта. Од сензора су коришћени акцелерометри који мере убрзање (уствари се мери сила која делује на сензор), жироскопи који мере угаону брзину и сензори који мере јачину звука. Врсте транспорта у којима су вршена мерења су аутобус, воз, аутомобил, шетање и мировање.

Пробаћемо да направимо што бољи модел за предвиђање врсте транспорта у на основу мерења са сензора користећи технике истраживања података.

import pandas as pd
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.preprocessing import StandardScaler, MinMaxScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import classification_report, confusion_matrix

df = pd.read_csv("/home/stiv/Desktop/ip_seminarski/archive/dataset_5secondWindow%5B1%5D.csv")

df

	time	android.sensor.accelerometer#mean	android.sensor.accelerometer#min	android.sensor.accelerometer#max	android.sensor.accelerometer#std	android.sensor.gyroscope#mean	android.sensor.gyroscope#min	android.sensor.gyroscope#max	android.sensor.gyroscope#std	sound#mean	sound#min	sound#max	sound#std	target
0	78.0	9.811476	9.758895	9.849411	0.014626	0.001651	0.000000	0.003533	0.000737	0.000000	0.000000	0.000000	0.000000	Still
1	145.0	9.939207	7.707437	17.146631	1.775944	0.036326	0.011669	0.059388	0.020290	89.200210	89.065143	89.335277	0.191013	Car
2	150.0	9.827178	9.804817	9.849262	0.011199	0.001525	0.000000	0.002609	0.000713	0.000000	0.000000	0.000000	0.000000	Still
3	105.0	9.673039	7.659674	12.304298	0.862553	0.036440	0.020463	0.052512	0.010553	87.470377	87.470377	87.470377	2.284186	Car
4	77.0	9.993466	8.965621	10.891645	0.504117	0.183202	0.020667	0.380875	0.098819	89.770732	89.770732	89.770732	0.006389	Car
...	...	...	...	...	...	...	...	...	...	...	...	...	...	...
5888	4.0	10.066610	4.564648	13.414389	3.373972	0.627658	0.076466	1.579251	0.389385	0.000000	0.000000	0.000000	0.000000	Walking
5889	32.0	9.964271	8.768007	11.454213	0.665529	0.018259	0.011517	0.030134	0.005964	0.000000	0.000000	0.000000	0.000000	Train
5890	86.0	9.812893	9.772881	9.862587	0.017633	0.001803	0.000000	0.004520	0.000904	0.000000	0.000000	0.000000	0.000000	Still
5891	199.0	9.831144	9.807347	9.874450	0.013485	0.003652	0.002732	0.004571	0.001301	0.000000	0.000000	0.000000	0.000000	Still
5892	55.0	11.051009	5.203285	19.921068	4.745098	1.454408	0.288313	3.272798	0.882147	89.712441	89.712441	89.712441	0.006400	Walking

5893 rows × 14 columns

df.isna().sum()

time                                 0
android.sensor.accelerometer#mean    0
android.sensor.accelerometer#min     0
android.sensor.accelerometer#max     0
android.sensor.accelerometer#std     0
android.sensor.gyroscope#mean        0
android.sensor.gyroscope#min         0
android.sensor.gyroscope#max         0
android.sensor.gyroscope#std         0
sound#mean                           0
sound#min                            0
sound#max                            0
sound#std                            0
target                               0
dtype: int64

df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 5893 entries, 0 to 5892
Data columns (total 14 columns):
 #   Column                             Non-Null Count  Dtype  
---  ------                             --------------  -----  
 0   time                               5893 non-null   float64
 1   android.sensor.accelerometer#mean  5893 non-null   float64
 2   android.sensor.accelerometer#min   5893 non-null   float64
 3   android.sensor.accelerometer#max   5893 non-null   float64
 4   android.sensor.accelerometer#std   5893 non-null   float64
 5   android.sensor.gyroscope#mean      5893 non-null   float64
 6   android.sensor.gyroscope#min       5893 non-null   float64
 7   android.sensor.gyroscope#max       5893 non-null   float64
 8   android.sensor.gyroscope#std       5893 non-null   float64
 9   sound#mean                         5893 non-null   float64
 10  sound#min                          5893 non-null   float64
 11  sound#max                          5893 non-null   float64
 12  sound#std                          5893 non-null   float64
 13  target                             5893 non-null   object 
dtypes: float64(13), object(1)
memory usage: 644.7+ KB

Средње вредности атрибута, груписаних по вредности циљног атрибута.

df.groupby('target').agg(lambda x: x.mean())

	time	android.sensor.accelerometer#mean	android.sensor.accelerometer#min	android.sensor.accelerometer#max	android.sensor.accelerometer#std	android.sensor.gyroscope#mean	android.sensor.gyroscope#min	android.sensor.gyroscope#max	android.sensor.gyroscope#std	sound#mean	sound#min	sound#max	sound#std
target
Bus	50.646859	9.773135	8.445846	11.318510	0.668055	0.162470	0.044722	0.458157	0.115465	69.502293	69.359466	69.636638	0.649447
Car	151.455932	9.850996	8.470982	11.410136	0.678361	0.075527	0.025362	0.186879	0.051234	68.394958	68.177520	68.612516	1.271003
Still	166.601357	9.860211	9.607460	10.178337	0.100241	0.049901	0.022828	0.100154	0.045606	46.914216	46.436094	47.389820	2.582698
Train	122.157761	9.902200	9.405749	10.435318	0.250731	0.053173	0.021653	0.134153	0.039116	75.166101	75.047348	75.297184	1.012460
Walking	97.677145	10.654371	6.197472	17.905676	3.221334	1.032043	0.278591	2.349954	0.582685	67.256262	67.077971	67.429599	1.076760

Од података које користимо за предвиђање врсте транспорта имамо дужину временског интервала у којем су вршена мерења са сензора и за сваки сензор имамо средњу вредност, стандардну девијацију, минимум и максимум измерених вредности у том временском интервалу.

features = df.columns[:-1]
x = df[features]
y = df['target']

Делимо податке на тренинг и тест скуп и вршимо стандардизацију података.

x_train, x_test, y_train, y_test = train_test_split(x,y,test_size=0.3,stratify=y,random_state=1234567)

scaler = StandardScaler().fit(x_train)
x_trans_train = scaler.transform(x_train)
x_trans_test = scaler.transform(x_test)

KNN алгоритам

Тестирамо различите параметре за обучавање модела са алгоритмом К најближих суседа, користећи унакрсну валидацију. Затим штампамо извештај о понашању модела над тренинг и тест скупом.

parameters = [{'n_neighbors': [3,5,10,25,50,100],
              'weights': ['distance','uniform'],
              'p': [1,2]}]

clf = GridSearchCV(KNeighborsClassifier(), param_grid=parameters, cv=7)
clf.fit(x_trans_train, y_train)
print(clf.best_params_)

{'n_neighbors': 3, 'p': 1, 'weights': 'distance'}

def izvestaj(y_true, x_test, clf,message=""):
    print("Izvestaj: ",message)
    print(classification_report(y_true, clf.predict(x_test)))
    print("Matrica konfuzije")
    print(pd.DataFrame(confusion_matrix(y_true,clf.predict(x_test)),index =clf.classes_,columns =clf.classes_))
    print('---------------------------------------------')

izvestaj(y_train,x_trans_train,clf.best_estimator_,"Trening skup")
izvestaj(y_test,x_trans_test,clf.best_estimator_,"Test skup")

Izvestaj:  Trening skup
              precision    recall  f1-score   support

         Bus       1.00      1.00      1.00       825
         Car       1.00      1.00      1.00       826
       Still       1.00      1.00      1.00       825
       Train       1.00      1.00      1.00       825
     Walking       1.00      1.00      1.00       824

    accuracy                           1.00      4125
   macro avg       1.00      1.00      1.00      4125
weighted avg       1.00      1.00      1.00      4125

Matrica konfuzije
         Bus  Car  Still  Train  Walking
Bus      825    0      0      0        0
Car        0  826      0      0        0
Still      0    0    825      0        0
Train      0    0      0    825        0
Walking    0    0      0      0      824
---------------------------------------------
Izvestaj:  Test skup
              precision    recall  f1-score   support

         Bus       0.80      0.81      0.80       353
         Car       0.79      0.73      0.76       354
       Still       0.94      0.91      0.92       354
       Train       0.79      0.85      0.82       354
     Walking       0.91      0.93      0.92       353

    accuracy                           0.85      1768
   macro avg       0.85      0.85      0.85      1768
weighted avg       0.85      0.85      0.85      1768

Matrica konfuzije
         Bus  Car  Still  Train  Walking
Bus      285   32      1     24       11
Car       44  257      9     40        4
Still      5    8    322     12        7
Train     16   19      9    301        9
Walking    8    8      3      4      330
---------------------------------------------

Видимо да се модел преприлагодио тренинг скупу. Пошто су најбољи параметри узети за параметар n_neighbors узели вредност 3 (најмањи од свих разматраних), покушаћемо да повећамо број суседа, како бисмо добили мање прилагођен модел.

parameters2 = [{'n_neighbors': [15,25,50],
              'weights': ['distance','uniform'],
              'p': [2]}]

clf2 = GridSearchCV(KNeighborsClassifier(), param_grid=parameters2, cv=5)
clf2.fit(x_trans_train, y_train)
print(clf2.best_params_)

{'n_neighbors': 15, 'p': 2, 'weights': 'distance'}

izvestaj(y_train,x_trans_train,clf2.best_estimator_,"Trening skup")
izvestaj(y_test,x_trans_test,clf2.best_estimator_,"Test skup")

Izvestaj:  Trening skup
              precision    recall  f1-score   support

         Bus       1.00      1.00      1.00       825
         Car       1.00      1.00      1.00       826
       Still       1.00      1.00      1.00       825
       Train       1.00      1.00      1.00       825
     Walking       1.00      1.00      1.00       824

    accuracy                           1.00      4125
   macro avg       1.00      1.00      1.00      4125
weighted avg       1.00      1.00      1.00      4125

Matrica konfuzije
         Bus  Car  Still  Train  Walking
Bus      825    0      0      0        0
Car        0  826      0      0        0
Still      0    0    825      0        0
Train      0    0      0    825        0
Walking    0    0      0      0      824
---------------------------------------------
Izvestaj:  Test skup
              precision    recall  f1-score   support

         Bus       0.72      0.76      0.74       353
         Car       0.80      0.61      0.69       354
       Still       0.91      0.89      0.90       354
       Train       0.72      0.84      0.77       354
     Walking       0.90      0.92      0.91       353

    accuracy                           0.81      1768
   macro avg       0.81      0.81      0.80      1768
weighted avg       0.81      0.81      0.80      1768

Matrica konfuzije
         Bus  Car  Still  Train  Walking
Bus      269   31      2     38       13
Car       57  215     12     60       10
Still      6    6    316     15       11
Train     31    9     12    298        4
Walking    9    8      5      5      326
---------------------------------------------

Модел је и даље преприлагођен. Сада ћемо узети униформну тежину за вредновање тежина суседа.

parameters3 = [{'n_neighbors': [5,15,25],
              'weights': ['uniform'],
              'p': [1,2]}]

clf3 = GridSearchCV(KNeighborsClassifier(), param_grid=parameters3, cv=5)
clf3.fit(x_trans_train, y_train)
print(clf3.best_params_)

{'n_neighbors': 5, 'p': 1, 'weights': 'uniform'}

izvestaj(y_train,x_trans_train,clf3.best_estimator_,"Trening skup")
izvestaj(y_test,x_trans_test,clf3.best_estimator_,"Test skup")

Izvestaj:  Trening skup
              precision    recall  f1-score   support

         Bus       0.82      0.91      0.86       825
         Car       0.87      0.81      0.84       826
       Still       0.94      0.93      0.93       825
       Train       0.89      0.87      0.88       825
     Walking       0.94      0.93      0.94       824

    accuracy                           0.89      4125
   macro avg       0.89      0.89      0.89      4125
weighted avg       0.89      0.89      0.89      4125

Matrica konfuzije
         Bus  Car  Still  Train  Walking
Bus      752   23      5     25       20
Car       93  671     10     43        9
Still     17   19    766     12       11
Train     36   45     21    718        5
Walking   21   12     13      9      769
---------------------------------------------
Izvestaj:  Test skup
              precision    recall  f1-score   support

         Bus       0.73      0.82      0.77       353
         Car       0.81      0.69      0.74       354
       Still       0.92      0.89      0.90       354
       Train       0.79      0.80      0.79       354
     Walking       0.91      0.93      0.92       353

    accuracy                           0.83      1768
   macro avg       0.83      0.83      0.83      1768
weighted avg       0.83      0.83      0.83      1768

Matrica konfuzije
         Bus  Car  Still  Train  Walking
Bus      291   24      2     24       12
Car       62  245      9     34        4
Still      7    9    314     15        9
Train     28   20     15    284        7
Walking   11    6      3      4      329
---------------------------------------------

Модел је сада мање преприлагођен, али нема бољи резултат на тест скупу.

PCA анализа компонената

Прво ћемо урадити PCA анализу на цео скуп података

from sklearn.decomposition import PCA

scaler2 = StandardScaler().fit(x)
x_trans = pd.DataFrame(scaler2.transform(x), columns=features)

pca=PCA()
pca.fit(x_trans)

pca_columns = ['pca%d'%i for i in range(1, pca.n_components_+1)]

pca_x = pd.DataFrame(pca.transform(x_trans), columns=pca_columns)

Искористићемо прва два најзначајнија фактора како бисмо графички приказали цео скуп података.

import matplotlib.pyplot as plt
import numpy as np

colors = ['red', 'blue', 'gold', 'green', 'indigo']

classes =y.unique()
plt.figure(figsize=(12,12))

for i, class_value in zip(range(0, len(classes)), classes):
    class_samples = pca_x[y == class_value]

    plt.scatter(class_samples['pca1'], class_samples['pca2'], color=colors[i],
                s=10, marker='o', label="class %s" % class_value)

plt.legend(loc='best')
plt.xlabel('PCA FAKTOR 1')
plt.ylabel('PCA FAKTOR 2')
plt.show()

Сада ћемо урадити PCA анализу обучавањем само над подацима за тренинг скуп. Направићемо нови модел, који ће уместо стандардизованог скупа свих атрибута за предвиђање користити редукован скуп атрибута који ћемо добити PCA анализом.

pca=PCA()
pca.fit(x_trans_train)

pca_columns = ['pca%d'%i for i in range(1, pca.n_components_+1)]

print('explained_variance_ratio_  ')

for i, evr in zip(range(1, len(features)+1), pca.explained_variance_ratio_):
    print("pca%d: %.10f"%(i,evr))
print()

x_pca_train = pd.DataFrame(pca.transform(x_trans_train), columns=pca_columns)

x_pca_test = pd.DataFrame(pca.transform(x_trans_test), columns=pca_columns)

explained_variance_ratio_  
pca1: 0.4423777459
pca2: 0.2325728393
pca3: 0.0852688501
pca4: 0.0711532860
pca5: 0.0619767017
pca6: 0.0440064578
pca7: 0.0382937854
pca8: 0.0121752804
pca9: 0.0050755704
pca10: 0.0042048379
pca11: 0.0027247588
pca12: 0.0001680506
pca13: 0.0000018358

Графички приказујемо кумулативну варијансу добијених фактора почевши од најзначајнијег.

plt.plot(pca_columns,  np.cumsum(pca.explained_variance_ratio_), color='darkorange', label='Kumulativna varijansa',  marker='o')

plt.xlabel('Glavne komponente')
plt.ylabel('Procent objasnjene varijanse')
plt.legend()

plt.show()

pd.Series(np.cumsum(pca.explained_variance_ratio_),index=pca_columns)

pca1     0.442378
pca2     0.674951
pca3     0.760219
pca4     0.831373
pca5     0.893349
pca6     0.937356
pca7     0.975650
pca8     0.987825
pca9     0.992901
pca10    0.997105
pca11    0.999830
pca12    0.999998
pca13    1.000000
dtype: float64

Видимо да 9 најзначајнијих фактора имају кумулативну варијансу преко 99%. Стога ћемо њих користити за класификацију.

pca=PCA(n_components=9)
pca.fit(x_trans_train)

PCA(n_components=9)

x_pca_train =  pd.DataFrame(pca.transform(x_trans_train))
x_pca_test =  pd.DataFrame(pca.transform(x_trans_test))

parameters4 = [{'n_neighbors': [5,15,25],
              'weights': ['distance','uniform'],
              'p': [1,2]}]

clf4 = GridSearchCV(KNeighborsClassifier(), param_grid=parameters4, cv=6)
clf4.fit(x_pca_train, y_train)
print(clf4.best_params_)

{'n_neighbors': 5, 'p': 1, 'weights': 'distance'}

izvestaj(y_train,x_pca_train,clf4.best_estimator_,"Trening skup")
izvestaj(y_test,x_pca_test,clf4.best_estimator_,"Test skup")

Izvestaj:  Trening skup
              precision    recall  f1-score   support

         Bus       1.00      1.00      1.00       825
         Car       1.00      1.00      1.00       826
       Still       1.00      1.00      1.00       825
       Train       1.00      1.00      1.00       825
     Walking       1.00      1.00      1.00       824

    accuracy                           1.00      4125
   macro avg       1.00      1.00      1.00      4125
weighted avg       1.00      1.00      1.00      4125

Matrica konfuzije
         Bus  Car  Still  Train  Walking
Bus      825    0      0      0        0
Car        0  826      0      0        0
Still      0    0    825      0        0
Train      0    0      0    825        0
Walking    0    0      0      0      824
---------------------------------------------
Izvestaj:  Test skup
              precision    recall  f1-score   support

         Bus       0.72      0.76      0.74       353
         Car       0.77      0.66      0.71       354
       Still       0.94      0.89      0.92       354
       Train       0.76      0.84      0.80       354
     Walking       0.88      0.92      0.90       353

    accuracy                           0.82      1768
   macro avg       0.82      0.82      0.81      1768
weighted avg       0.82      0.82      0.81      1768

Matrica konfuzije
         Bus  Car  Still  Train  Walking
Bus      270   35      2     34       12
Car       58  235      7     43       11
Still      9    8    315     10       12
Train     23   18      8    296        9
Walking   13    9      2      4      325
---------------------------------------------

parameters5 = [{'n_neighbors': [7,15,25],
              'weights': ['uniform'],
              'p': [1,2]}]

clf5 = GridSearchCV(KNeighborsClassifier(), param_grid=parameters5, cv=6)
clf5.fit(x_pca_train, y_train)
print(clf5.best_params_)

{'n_neighbors': 7, 'p': 1, 'weights': 'uniform'}

izvestaj(y_train,x_pca_train,clf5.best_estimator_,"Trening skup")
izvestaj(y_test,x_pca_test,clf5.best_estimator_,"Test skup")

Izvestaj:  Trening skup
              precision    recall  f1-score   support

         Bus       0.78      0.86      0.82       825
         Car       0.84      0.76      0.79       826
       Still       0.92      0.91      0.91       825
       Train       0.82      0.85      0.84       825
     Walking       0.92      0.91      0.91       824

    accuracy                           0.86      4125
   macro avg       0.86      0.86      0.86      4125
weighted avg       0.86      0.86      0.86      4125

Matrica konfuzije
         Bus  Car  Still  Train  Walking
Bus      706   39      5     45       30
Car      102  625     16     67       16
Still     15   21    748     27       14
Train     45   50     22    700        8
Walking   33   12     20     11      748
---------------------------------------------
Izvestaj:  Test skup
              precision    recall  f1-score   support

         Bus       0.70      0.78      0.74       353
         Car       0.78      0.63      0.69       354
       Still       0.92      0.88      0.90       354
       Train       0.73      0.81      0.77       354
     Walking       0.89      0.92      0.91       353

    accuracy                           0.80      1768
   macro avg       0.80      0.80      0.80      1768
weighted avg       0.80      0.80      0.80      1768

Matrica konfuzije
         Bus  Car  Still  Train  Walking
Bus      274   30      2     36       11
Car       67  222      8     46       11
Still      8    7    311     18       10
Train     30   19     13    285        7
Walking   11    8      5      4      325
---------------------------------------------

И даље су нам модели слични као и кад смо користили цели скуп атрибута, па закључујемо да се коришћењем KNN алгоритма не може направити пуно бољи модел за овај проблем.

Дрвета одлучивања

Тестирамо различите параметре за обучавање модела са дрветима одлучивања, користећи унакрсну валидацију. Затим штампамо извештај о понашању модела над тренинг и тест скупом.

from sklearn.tree import DecisionTreeClassifier, plot_tree

parameters6 = {'criterion' : ['gini', 'entropy'],
              'max_depth' : [3,4,5,6]}

clf6 = GridSearchCV(DecisionTreeClassifier(), param_grid=parameters6, cv=5,verbose=0)
clf6.fit(x_train, y_train)
clf6.best_params_

{'criterion': 'entropy', 'max_depth': 6}

izvestaj(y_train,x_train,clf6.best_estimator_,"Trening skup")
izvestaj(y_test,x_test,clf6.best_estimator_,"Test skup")

Izvestaj:  Trening skup
              precision    recall  f1-score   support

         Bus       0.78      0.57      0.66       825
         Car       0.58      0.66      0.62       826
       Still       0.91      0.78      0.84       825
       Train       0.55      0.75      0.63       825
     Walking       0.94      0.84      0.89       824

    accuracy                           0.72      4125
   macro avg       0.75      0.72      0.73      4125
weighted avg       0.75      0.72      0.73      4125

Matrica konfuzije
         Bus  Car  Still  Train  Walking
Bus      473  137      2    187       26
Car       81  544      8    187        6
Still     15   78    640     80       12
Train     22  150     28    622        3
Walking   15   28     22     64      695
---------------------------------------------
Izvestaj:  Test skup
              precision    recall  f1-score   support

         Bus       0.76      0.53      0.62       353
         Car       0.59      0.64      0.61       354
       Still       0.91      0.72      0.81       354
       Train       0.53      0.78      0.63       354
     Walking       0.92      0.86      0.89       353

    accuracy                           0.71      1768
   macro avg       0.74      0.71      0.71      1768
weighted avg       0.74      0.71      0.71      1768

Matrica konfuzije
         Bus  Car  Still  Train  Walking
Bus      187   56      1     98       11
Car       35  226      5     83        5
Still      5   39    256     44       10
Train      7   57     13    276        1
Walking   13    6      7     23      304
---------------------------------------------

Покушавамо опет са мало већом дубином

parameters7 = {'criterion' : ['gini', 'entropy'],
              'max_depth' : [5,6,7,8]}

clf7 = GridSearchCV(DecisionTreeClassifier(), param_grid=parameters7, cv=5,verbose=0)
clf7.fit(x_train, y_train)
clf7.best_params_

{'criterion': 'gini', 'max_depth': 8}

izvestaj(y_train,x_train,clf7.best_estimator_,"Trening skup")
izvestaj(y_test,x_test,clf7.best_estimator_,"Test skup")

Izvestaj:  Trening skup
              precision    recall  f1-score   support

         Bus       0.67      0.84      0.75       825
         Car       0.73      0.70      0.71       826
       Still       0.92      0.85      0.88       825
       Train       0.78      0.70      0.74       825
     Walking       0.95      0.91      0.93       824

    accuracy                           0.80      4125
   macro avg       0.81      0.80      0.80      4125
weighted avg       0.81      0.80      0.80      4125

Matrica konfuzije
         Bus  Car  Still  Train  Walking
Bus      694   59      8     48       16
Car      151  575     14     79        7
Still     40   41    704     31        9
Train    120   86     33    579        7
Walking   32   25     10      6      751
---------------------------------------------
Izvestaj:  Test skup
              precision    recall  f1-score   support

         Bus       0.64      0.81      0.72       353
         Car       0.68      0.64      0.66       354
       Still       0.89      0.76      0.82       354
       Train       0.72      0.67      0.69       354
     Walking       0.89      0.90      0.90       353

    accuracy                           0.76      1768
   macro avg       0.76      0.76      0.76      1768
weighted avg       0.76      0.76      0.76      1768

Matrica konfuzije
         Bus  Car  Still  Train  Walking
Bus      287   30      1     25       10
Car       79  226      7     37        5
Still     15   24    269     26       20
Train     55   37     22    236        4
Walking   13   14      2      5      319
---------------------------------------------

Додајемо и ограничење за минималну добит. Цртамо дрво да бисмо видели који су најзачајнији атрибути при одлучивању дрвета.

parameters8 = {'criterion' : ['gini', 'entropy'],
              'max_depth' : [4,5],
              'min_impurity_decrease': [0.05, 0.1]}

clf8 = GridSearchCV(DecisionTreeClassifier(), param_grid=parameters8, cv=5,verbose=0)
clf8.fit(x_train, y_train)
clf8.best_params_

{'criterion': 'entropy', 'max_depth': 4, 'min_impurity_decrease': 0.05}

izvestaj(y_train,x_train,clf8.best_estimator_,"Trening skup")
izvestaj(y_test,x_test,clf8.best_estimator_,"Test skup")

Izvestaj:  Trening skup
              precision    recall  f1-score   support

         Bus       0.64      0.49      0.56       825
         Car       0.48      0.54      0.51       826
       Still       0.73      0.74      0.74       825
       Train       0.52      0.62      0.57       825
     Walking       0.87      0.77      0.81       824

    accuracy                           0.63      4125
   macro avg       0.65      0.63      0.64      4125
weighted avg       0.65      0.63      0.64      4125

Matrica konfuzije
         Bus  Car  Still  Train  Walking
Bus      405  146     48    169       57
Car      111  446     51    181       37
Still     16   96    612     98        3
Train     25  183    101    515        1
Walking   75   65     22     30      632
---------------------------------------------
Izvestaj:  Test skup
              precision    recall  f1-score   support

         Bus       0.64      0.49      0.55       353
         Car       0.51      0.53      0.52       354
       Still       0.75      0.71      0.73       354
       Train       0.52      0.69      0.59       354
     Walking       0.88      0.79      0.83       353

    accuracy                           0.64      1768
   macro avg       0.66      0.64      0.65      1768
weighted avg       0.66      0.64      0.65      1768

Matrica konfuzije
         Bus  Car  Still  Train  Walking
Bus      172   61     17     87       16
Car       46  187     17     85       19
Still     13   36    252     49        4
Train      7   55     45    246        1
Walking   29   29      6      9      280
---------------------------------------------

plt.figure(figsize=(40,15))
t = plot_tree(clf8.best_estimator_,filled=True,
      feature_names=features, class_names=clf8.best_estimator_.classes_,fontsize=30, impurity=False)

plt.tight_layout()

Закључујемо да су се дрвета лошије показала за класификацију у овом проблему односу на алгоритам К најближих суседа.

Вештачке неуронске мреже

Тестирамо различите параметре за обучавање модела са вештачким неуронским мрежама, користећи унакрсну валидацију. Затим штампамо извештај о понашању модела над тренинг и тест скупом.

from sklearn.neural_network import MLPClassifier

Користићемо атрибуте добијене PCA анализом, као у улаз у вештачку мрежу.

parameters9 ={'hidden_layer_sizes': [(15,10,5), (10,10), (8,8,8), (10,5,5), (5,4,3)],
             'activation': ['identity', 'logistic', 'tanh', 'relu'],
             'learning_rate' : ['constant', 'invscaling', 'adaptive'],
             'learning_rate_init':[0.01, 0.005, 0.002],
             'max_iter': [500]}

clf9 = GridSearchCV(MLPClassifier(), param_grid= parameters9, cv=5)
clf9.fit(x_pca_train, y_train)
clf9.best_params_

clf9.best_params_

{'activation': 'tanh',
 'hidden_layer_sizes': (15, 10, 5),
 'learning_rate': 'invscaling',
 'learning_rate_init': 0.005,
 'max_iter': 500}

izvestaj(y_train,x_pca_train,clf9.best_estimator_,"Trening skup")
izvestaj(y_test,x_pca_test,clf9.best_estimator_,"Test skup")

Izvestaj:  Trening skup
              precision    recall  f1-score   support

         Bus       0.72      0.77      0.75       825
         Car       0.69      0.72      0.70       826
       Still       0.90      0.90      0.90       825
       Train       0.78      0.70      0.74       825
     Walking       0.91      0.92      0.91       824

    accuracy                           0.80      4125
   macro avg       0.80      0.80      0.80      4125
weighted avg       0.80      0.80      0.80      4125

Matrica konfuzije
         Bus  Car  Still  Train  Walking
Bus      636   95     18     49       27
Car      116  591     17     82       20
Still     25   17    742     23       18
Train     81  130     29    578        7
Walking   20   19     22      9      754
---------------------------------------------
Izvestaj:  Test skup
              precision    recall  f1-score   support

         Bus       0.69      0.71      0.70       353
         Car       0.65      0.62      0.63       354
       Still       0.85      0.85      0.85       354
       Train       0.72      0.73      0.72       354
     Walking       0.89      0.89      0.89       353

    accuracy                           0.76      1768
   macro avg       0.76      0.76      0.76      1768
weighted avg       0.76      0.76      0.76      1768

Matrica konfuzije
         Bus  Car  Still  Train  Walking
Bus      252   51      7     30       13
Car       60  218     16     47       13
Still     14   11    301     19        9
Train     29   43     20    257        5
Walking   12   14      9      4      314
---------------------------------------------

Узећемо најбоље параметре и повећати број неурона, пошто је за најбољи узет онај са највише неурона и слојева од понуђених.

parameters10 ={'hidden_layer_sizes': [(20,15,10),(40,20),(40,30,20),(15,10,5)],
             'activation': ['tanh'],
             'learning_rate' : ['adaptive'],
             'learning_rate_init':[0.005],
             'max_iter': [500]}

clf10 = GridSearchCV(MLPClassifier(), param_grid= parameters10, cv=5)
clf10.fit(x_pca_train, y_train)
clf10.best_params_

{'activation': 'tanh',
 'hidden_layer_sizes': (40, 30, 20),
 'learning_rate': 'adaptive',
 'learning_rate_init': 0.005,
 'max_iter': 500}

izvestaj(y_train,x_pca_train,clf10.best_estimator_,"Trening skup")
izvestaj(y_test,x_pca_test,clf10.best_estimator_,"Test skup")

Izvestaj:  Trening skup
              precision    recall  f1-score   support

         Bus       0.96      0.97      0.96       825
         Car       0.96      0.94      0.95       826
       Still       0.98      0.99      0.99       825
       Train       0.95      0.95      0.95       825
     Walking       0.99      0.99      0.99       824

    accuracy                           0.97      4125
   macro avg       0.97      0.97      0.97      4125
weighted avg       0.97      0.97      0.97      4125

Matrica konfuzije
         Bus  Car  Still  Train  Walking
Bus      800    8      3     12        2
Car       23  773      1     28        1
Still      1    1    819      2        2
Train      9   21     10    784        1
Walking    1    4      0      3      816
---------------------------------------------
Izvestaj:  Test skup
              precision    recall  f1-score   support

         Bus       0.76      0.79      0.78       353
         Car       0.76      0.69      0.72       354
       Still       0.93      0.88      0.90       354
       Train       0.78      0.80      0.79       354
     Walking       0.85      0.91      0.88       353

    accuracy                           0.82      1768
   macro avg       0.82      0.82      0.82      1768
weighted avg       0.82      0.82      0.82      1768

Matrica konfuzije
         Bus  Car  Still  Train  Walking
Bus      280   34      1     23       15
Car       41  246      9     43       15
Still     12    6    311     11       14
Train     22   24     13    284       11
Walking   13   15      2      2      321
---------------------------------------------

Сада смо мало побољшали прецизност на тест скупу, али је модел преприлагођенији.

parameters11 ={'hidden_layer_sizes': [(30,20,10)],
             'activation': ['tanh'],
             'learning_rate' : ['adaptive'],
             'learning_rate_init':[0.005],
             'max_iter': [500]}

clf11 = GridSearchCV(MLPClassifier(), param_grid= parameters11, cv=5)
clf11.fit(x_pca_train, y_train)
clf11.best_params_

{'activation': 'tanh',
 'hidden_layer_sizes': (30, 20, 10),
 'learning_rate': 'adaptive',
 'learning_rate_init': 0.005,
 'max_iter': 500}

izvestaj(y_train,x_pca_train,clf11.best_estimator_,"Trening skup")
izvestaj(y_test,x_pca_test,clf11.best_estimator_,"Test skup")

Izvestaj:  Trening skup
              precision    recall  f1-score   support

         Bus       0.88      0.90      0.89       825
         Car       0.84      0.85      0.84       826
       Still       0.97      0.97      0.97       825
       Train       0.88      0.86      0.87       825
     Walking       0.98      0.97      0.97       824

    accuracy                           0.91      4125
   macro avg       0.91      0.91      0.91      4125
weighted avg       0.91      0.91      0.91      4125

Matrica konfuzije
         Bus  Car  Still  Train  Walking
Bus      741   48      3     25        8
Car       59  704      5     55        3
Still      6    5    797     10        7
Train     30   71     12    711        1
Walking    4   13      2      7      798
---------------------------------------------
Izvestaj:  Test skup
              precision    recall  f1-score   support

         Bus       0.73      0.79      0.76       353
         Car       0.69      0.65      0.67       354
       Still       0.90      0.88      0.89       354
       Train       0.77      0.77      0.77       354
     Walking       0.89      0.90      0.90       353

    accuracy                           0.80      1768
   macro avg       0.80      0.80      0.80      1768
weighted avg       0.80      0.80      0.80      1768

Matrica konfuzije
         Bus  Car  Still  Train  Walking
Bus      280   39      1     17       16
Car       53  230      9     47       15
Still      6   15    312     15        6
Train     29   33     20    271        1
Walking   13   15      4      4      317
---------------------------------------------

parameters12 ={'hidden_layer_sizes': [(20,15,10)],
             'activation': ['tanh'],
             'learning_rate' : ['adaptive'],
             'learning_rate_init':[0.005],
             'max_iter': [1000]}

clf12 = GridSearchCV(MLPClassifier(), param_grid= parameters12, cv=5)
clf12.fit(x_pca_train, y_train)
clf12.best_params_

{'activation': 'tanh',
 'hidden_layer_sizes': (20, 15, 10),
 'learning_rate': 'adaptive',
 'learning_rate_init': 0.005,
 'max_iter': 1000}

izvestaj(y_train,x_pca_train,clf12.best_estimator_,"Trening skup")
izvestaj(y_test,x_pca_test,clf12.best_estimator_,"Test skup")

Izvestaj:  Trening skup
              precision    recall  f1-score   support

         Bus       0.80      0.83      0.82       825
         Car       0.79      0.72      0.75       826
       Still       0.93      0.92      0.93       825
       Train       0.77      0.83      0.80       825
     Walking       0.96      0.94      0.95       824

    accuracy                           0.85      4125
   macro avg       0.85      0.85      0.85      4125
weighted avg       0.85      0.85      0.85      4125

Matrica konfuzije
         Bus  Car  Still  Train  Walking
Bus      688   67      5     59        6
Car      100  595     15    103       13
Still     22    7    759     24       13
Train     36   76     23    688        2
Walking   14   10     13     16      771
---------------------------------------------
Izvestaj:  Test skup
              precision    recall  f1-score   support

         Bus       0.72      0.73      0.72       353
         Car       0.69      0.64      0.66       354
       Still       0.90      0.87      0.88       354
       Train       0.71      0.77      0.74       354
     Walking       0.90      0.91      0.91       353

    accuracy                           0.78      1768
   macro avg       0.78      0.78      0.78      1768
weighted avg       0.78      0.78      0.78      1768

Matrica konfuzije
         Bus  Car  Still  Train  Walking
Bus      256   48      3     34       12
Car       51  227     12     57        7
Still     12    8    307     17       10
Train     24   36     16    271        7
Walking   13   10      4      4      322
---------------------------------------------

SPSS modeler

Сада ћемо у програму SPSS modeler обучити још модела за класификацију коришћењем 2 алгоритма: C5.0 и Метод подржавајућих вектора (SVM)

from IPython.display import Image

Image(filename="/home/stiv/Desktop/ip_seminarski/spss.png") 

C5.0 алгоритам

Најзначајнији атрибути gyroscope#mean, accelerometer#min, accelerometer#max, gyroscope#min са значајношћу од 0.14, 0.10, 0.07 и 0.07 респективно.

Image(filename="/home/stiv/Desktop/ip_seminarski/Predictor_importance_c5.0.png") 

Добијамо опет преприлагођен модел.

Image(filename="/home/stiv/Desktop/ip_seminarski/confusion_matrix_c50.png") 

Дубина дрвета је 21.

Цртамо 3д график, на основу 3 најзначајнија атрибута.

Image(filename="/home/stiv/Desktop/ip_seminarski/3dplot_c5.0.png") 

Видимо да се сензоре мере највеће ротационо кретање када је у питању шетња као врста транспорта.

Метод подржавајућих вектора (SVM)

Прво смо урадили PCA анализу.

Image(filename="/home/stiv/Desktop/ip_seminarski/pca.png") 

Пошто првих 6 компонената по значајности има кумулативну варијансу од 97.48%, њих ћемо узети за даље обучавање модела.

Сада ћемо направити неколико модела коришћењем SVM алгоритма са различитим параметрима.

Kernel : Radial Basis Function

Image(filename="/home/stiv/Desktop/ip_seminarski/svm_rbf1.png")

Image(filename="/home/stiv/Desktop/ip_seminarski/svm_rbf2.png") 

Image(filename="/home/stiv/Desktop/ip_seminarski/svm_rbf3.png") 

Kernel : Sigmoid Function

Image(filename="/home/stiv/Desktop/ip_seminarski/svm_sgm1.png") 

Image(filename="/home/stiv/Desktop/ip_seminarski/svm_sgm2.png") 

Image(filename="/home/stiv/Desktop/ip_seminarski/svm_sgm3.png") 

Kernel : Polynomial Function

Image(filename="/home/stiv/Desktop/ip_seminarski/svm_poly1.png") 

Kernel : Linear Function

Image(filename="/home/stiv/Desktop/ip_seminarski/svm_lin1.png")

Image(filename="/home/stiv/Desktop/ip_seminarski/svm_lin2.png") 

Од свих модела које смо обучавали алгоритмом SVM најбоље се показао модел који је користио линеарни кернел и регуларизациони параметар C=8. На тренинг скупу је остварио прецизност од 60%, а на тест скупу 57%.

Закључак

Највећу прецизност од свих модела које смо направили је остварио модел направљен алгоритмом К најближих суседа.

На тренинг скупу је остварио 100% прецизност, док је на тест скупу остварио прецизност од 85%.

Параметри које је користио су: {'n_neighbors': 3, 'p': 1, 'weights': 'distance'}

Ипак, за најбољи модел ћемо узети стабилнији модел који је такође направљен алгоритмом К најближих суседа, али који је користио следеће параметре за обучавање: {'n_neighbors': 5, 'p': 1, 'weights': 'uniform'}

Његова прецизност на тренинг скупу је 89%, док је 83% прецизност на тест скупу.